/*
 * Copyright (c) 2023 iQi.Co.Ltd. All rights reserved.
 */
 
using System.Collections.Generic;
using NetProtocol.POD;
using NetProtocol.Enum;
using IQIGame.Onigao.Game;
using IQIGame.Onigao.GamePlay;
using IQIGame.Onigao.Framework;
using Cysharp.Threading.Tasks;
using System;
using static IQIGame.Onigao.Game.MessageWrapper;

namespace NetProtocol.Client {
	/// <summary>
	/// 关卡逻辑模块
	/// module : levelLogic
	/// </summary>
	public interface CNetLevelLogic : INetClientModule {
		
		public ISession GetSession();
	
		Dictionary<int, INetClientModule.Package2MessageWrapper> INetClientModule.GetModuleFunction()
        {
            MessageFunction NotifyEnter_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyEnterData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyEnter, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyEnter(session, _wrapper.message.level);
                MessageWrapperPool<NotifyEnterData>.Put(_wrapper);
            };
            MessageFunction ReadyToStartResult_Delegate = (session, wrapper) =>
            {
            	var _wrapper = (MessageWrapper<ReadyToStartResultData>)wrapper;
                SC_ReadyToStartResult(session, ref _wrapper.message);
                MessageWrapperPool<ReadyToStartResultData>.Put(_wrapper);
            };
            MessageFunction NotifyStart_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyStartData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyStart, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyStart(session);
                MessageWrapperPool<NotifyStartData>.Put(_wrapper);
            };
            MessageFunction NotifyLeave_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyLeaveData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyLeave, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyLeave(session, _wrapper.message.outRegionCid, _wrapper.message.outPortalMcid, _wrapper.message.anotherLevelCid);
                MessageWrapperPool<NotifyLeaveData>.Put(_wrapper);
            };
            MessageFunction EnterRegionResult_Delegate = (session, wrapper) =>
            {
            	var _wrapper = (MessageWrapper<EnterRegionResultData>)wrapper;
                SC_EnterRegionResult(session, ref _wrapper.message);
                MessageWrapperPool<EnterRegionResultData>.Put(_wrapper);
            };
            MessageFunction NotifyEnterRegion_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyEnterRegionData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyEnterRegion, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyEnterRegion(session, _wrapper.message.region);
                MessageWrapperPool<NotifyEnterRegionData>.Put(_wrapper);
            };
            MessageFunction NotifySyncPosition_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifySyncPositionData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifySyncPosition, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifySyncPosition(session, _wrapper.message.reason, _wrapper.message.entityId, _wrapper.message.entityType, _wrapper.message.x, _wrapper.message.y, _wrapper.message.z, _wrapper.message.speedRatio, _wrapper.message.dirType);
                MessageWrapperPool<NotifySyncPositionData>.Put(_wrapper);
            };
            MessageFunction UpdateEntities_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<UpdateEntitiesData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_UpdateEntities, "Recv->" + _wrapper.message.ToString());
#endif
                SC_UpdateEntities(session, _wrapper.message.modifiedList, _wrapper.message.removedList, _wrapper.message.isPlayDieWhenRemove);
                MessageWrapperPool<UpdateEntitiesData>.Put(_wrapper);
            };
            MessageFunction InteractResult_Delegate = (session, wrapper) =>
            {
            	var _wrapper = (MessageWrapper<InteractResultData>)wrapper;
                SC_InteractResult(session, ref _wrapper.message);
                MessageWrapperPool<InteractResultData>.Put(_wrapper);
            };
            MessageFunction LeaveResult_Delegate = (session, wrapper) =>
            {
            	var _wrapper = (MessageWrapper<LeaveResultData>)wrapper;
                SC_LeaveResult(session, ref _wrapper.message);
                MessageWrapperPool<LeaveResultData>.Put(_wrapper);
            };
            MessageFunction JumpResult_Delegate = (session, wrapper) =>
            {
            	var _wrapper = (MessageWrapper<JumpResultData>)wrapper;
                SC_JumpResult(session, ref _wrapper.message);
                MessageWrapperPool<JumpResultData>.Put(_wrapper);
            };
            MessageFunction NotifyBattleSettlement_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyBattleSettlementData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyBattleSettlement, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyBattleSettlement(session, _wrapper.message.settlementPOD);
                MessageWrapperPool<NotifyBattleSettlementData>.Put(_wrapper);
            };
            MessageFunction NotifyShowSpeechBubble_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyShowSpeechBubbleData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyShowSpeechBubble, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyShowSpeechBubble(session, _wrapper.message.entityId, _wrapper.message.bubbleGroupId, _wrapper.message.validBubbleIds);
                MessageWrapperPool<NotifyShowSpeechBubbleData>.Put(_wrapper);
            };
            MessageFunction UpdateEntityActivation_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<UpdateEntityActivationData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_UpdateEntityActivation, "Recv->" + _wrapper.message.ToString());
#endif
                SC_UpdateEntityActivation(session, _wrapper.message.entityIdList, _wrapper.message.isActive, _wrapper.message.animActionId, _wrapper.message.isSetRotation, _wrapper.message.rotationY);
                MessageWrapperPool<UpdateEntityActivationData>.Put(_wrapper);
            };
            MessageFunction NotifyActivateElevator_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyActivateElevatorData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyActivateElevator, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyActivateElevator(session, _wrapper.message.elevatorEntityId, _wrapper.message.targetFloor, _wrapper.message.isRidingMode, _wrapper.message.isMoveState);
                MessageWrapperPool<NotifyActivateElevatorData>.Put(_wrapper);
            };
            MessageFunction NotifyStartCameraMotion_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyStartCameraMotionData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyStartCameraMotion, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyStartCameraMotion(session, _wrapper.message.levelScreenSwitchCid);
                MessageWrapperPool<NotifyStartCameraMotionData>.Put(_wrapper);
            };
            MessageFunction NotifyEntityObstacleChange_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyEntityObstacleChangeData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyEntityObstacleChange, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyEntityObstacleChange(session, _wrapper.message.entityIds, _wrapper.message.isObstacleActive);
                MessageWrapperPool<NotifyEntityObstacleChangeData>.Put(_wrapper);
            };
            MessageFunction NotifyPlayEntityAnimAction_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyPlayEntityAnimActionData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyPlayEntityAnimAction, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyPlayEntityAnimAction(session, _wrapper.message.entityIds, _wrapper.message.actionId);
                MessageWrapperPool<NotifyPlayEntityAnimActionData>.Put(_wrapper);
            };
            MessageFunction NotifyLevelTimeShowChange_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyLevelTimeShowChangeData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyLevelTimeShowChange, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyLevelTimeShowChange(session, _wrapper.message.timeHour);
                MessageWrapperPool<NotifyLevelTimeShowChangeData>.Put(_wrapper);
            };
            MessageFunction NotifyChangeSceneEffect_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyChangeSceneEffectData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyChangeSceneEffect, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyChangeSceneEffect(session, _wrapper.message.entityId, _wrapper.message.sceneEffectId, _wrapper.message.isAdd);
                MessageWrapperPool<NotifyChangeSceneEffectData>.Put(_wrapper);
            };
            MessageFunction UpdateEntityRotationY_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<UpdateEntityRotationYData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_UpdateEntityRotationY, "Recv->" + _wrapper.message.ToString());
#endif
                SC_UpdateEntityRotationY(session, _wrapper.message.entityId, _wrapper.message.entityType, _wrapper.message.rotationY);
                MessageWrapperPool<UpdateEntityRotationYData>.Put(_wrapper);
            };
            MessageFunction NotifyActiveCheckPoint_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyActiveCheckPointData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyActiveCheckPoint, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyActiveCheckPoint(session, _wrapper.message.entityId, _wrapper.message.isActive);
                MessageWrapperPool<NotifyActiveCheckPointData>.Put(_wrapper);
            };
            MessageFunction NotifyBuffChange_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyBuffChangeData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyBuffChange, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyBuffChange(session, _wrapper.message.changes);
                MessageWrapperPool<NotifyBuffChangeData>.Put(_wrapper);
            };
            MessageFunction NotifyCustomBgmChange_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyCustomBgmChangeData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyCustomBgmChange, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyCustomBgmChange(session, _wrapper.message.bgmAudioCid);
                MessageWrapperPool<NotifyCustomBgmChangeData>.Put(_wrapper);
            };
            MessageFunction NotifyStartStoryDialog_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyStartStoryDialogData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyStartStoryDialog, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyStartStoryDialog(session, _wrapper.message.cid, _wrapper.message.jumpCid, _wrapper.message.entityId);
                MessageWrapperPool<NotifyStartStoryDialogData>.Put(_wrapper);
            };
            MessageFunction RepoStoryDialogSelectionResult_Delegate = (session, wrapper) =>
            {
            	var _wrapper = (MessageWrapper<RepoStoryDialogSelectionResultData>)wrapper;
                SC_RepoStoryDialogSelectionResult(session, ref _wrapper.message);
                MessageWrapperPool<RepoStoryDialogSelectionResultData>.Put(_wrapper);
            };
            MessageFunction NotifyChangeLevelParam_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyChangeLevelParamData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyChangeLevelParam, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyChangeLevelParam(session, _wrapper.message.key, _wrapper.message.value);
                MessageWrapperPool<NotifyChangeLevelParamData>.Put(_wrapper);
            };
            MessageFunction NotifyHeroFollowerChange_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyHeroFollowerChangeData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyHeroFollowerChange, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyHeroFollowerChange(session, _wrapper.message.id);
                MessageWrapperPool<NotifyHeroFollowerChangeData>.Put(_wrapper);
            };
            MessageFunction NotifyChangePlayerCamera_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyChangePlayerCameraData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyChangePlayerCamera, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyChangePlayerCamera(session, _wrapper.message.cameraCid);
                MessageWrapperPool<NotifyChangePlayerCameraData>.Put(_wrapper);
            };
            MessageFunction NotifyChangeWeather_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyChangeWeatherData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyChangeWeather, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyChangeWeather(session, _wrapper.message.id, _wrapper.message.weatherType);
                MessageWrapperPool<NotifyChangeWeatherData>.Put(_wrapper);
            };
            MessageFunction GetMapEntitiesResult_Delegate = (session, wrapper) =>
            {
            	var _wrapper = (MessageWrapper<GetMapEntitiesResultData>)wrapper;
                SC_GetMapEntitiesResult(session, ref _wrapper.message);
                MessageWrapperPool<GetMapEntitiesResultData>.Put(_wrapper);
            };
            MessageFunction UpdateEntityAlert_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<UpdateEntityAlertData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_UpdateEntityAlert, "Recv->" + _wrapper.message.ToString());
#endif
                SC_UpdateEntityAlert(session, _wrapper.message.entityId, _wrapper.message.targetEntityId, _wrapper.message.alertValue);
                MessageWrapperPool<UpdateEntityAlertData>.Put(_wrapper);
            };
            MessageFunction UpdateHeroCarrier_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<UpdateHeroCarrierData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_UpdateHeroCarrier, "Recv->" + _wrapper.message.ToString());
#endif
                SC_UpdateHeroCarrier(session, _wrapper.message.heroEntityId, _wrapper.message.entityId, _wrapper.message.isRemoved);
                MessageWrapperPool<UpdateHeroCarrierData>.Put(_wrapper);
            };
            MessageFunction NotifyLeaderHeroChanged_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyLeaderHeroChangedData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyLeaderHeroChanged, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyLeaderHeroChanged(session, _wrapper.message.heroEntityId, _wrapper.message.leaderHeroPOD);
                MessageWrapperPool<NotifyLeaderHeroChangedData>.Put(_wrapper);
            };
            MessageFunction NotifyStartItemSubmit_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyStartItemSubmitData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyStartItemSubmit, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyStartItemSubmit(session, _wrapper.message.itemSubmitCid);
                MessageWrapperPool<NotifyStartItemSubmitData>.Put(_wrapper);
            };
            MessageFunction ConfirmItemSubmitResult_Delegate = (session, wrapper) =>
            {
            	var _wrapper = (MessageWrapper<ConfirmItemSubmitResultData>)wrapper;
                SC_ConfirmItemSubmitResult(session, ref _wrapper.message);
                MessageWrapperPool<ConfirmItemSubmitResultData>.Put(_wrapper);
            };
            MessageFunction AcceptQuestResult_Delegate = (session, wrapper) =>
            {
            	var _wrapper = (MessageWrapper<AcceptQuestResultData>)wrapper;
                SC_AcceptQuestResult(session, ref _wrapper.message);
                MessageWrapperPool<AcceptQuestResultData>.Put(_wrapper);
            };
            MessageFunction NotifyDrop_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyDropData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyDrop, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyDrop(session, _wrapper.message.srcEntityId, _wrapper.message.items);
                MessageWrapperPool<NotifyDropData>.Put(_wrapper);
            };
            MessageFunction NotifyClearHeroBuff_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyClearHeroBuffData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyClearHeroBuff, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyClearHeroBuff(session, _wrapper.message.pid, _wrapper.message.heroId);
                MessageWrapperPool<NotifyClearHeroBuffData>.Put(_wrapper);
            };
            MessageFunction NotifyTeamWipe_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyTeamWipeData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyTeamWipe, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyTeamWipe(session, _wrapper.message.pid, _wrapper.message.leaderHeroId);
                MessageWrapperPool<NotifyTeamWipeData>.Put(_wrapper);
            };
            MessageFunction NotifyHeroesAttr_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyHeroesAttrData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyHeroesAttr, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyHeroesAttr(session, _wrapper.message.pid, _wrapper.message.heroAttrs, _wrapper.message.reason);
                MessageWrapperPool<NotifyHeroesAttrData>.Put(_wrapper);
            };
            MessageFunction NotifyPlayOrStopEntityEffect_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyPlayOrStopEntityEffectData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyPlayOrStopEntityEffect, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyPlayOrStopEntityEffect(session, _wrapper.message.singleEntityId, _wrapper.message.multiEntityIds, _wrapper.message.effectResCid, _wrapper.message.bindPointCid, _wrapper.message.isAdd);
                MessageWrapperPool<NotifyPlayOrStopEntityEffectData>.Put(_wrapper);
            };
            MessageFunction NotifyRevive_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyReviveData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyRevive, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyRevive(session, _wrapper.message.pid);
                MessageWrapperPool<NotifyReviveData>.Put(_wrapper);
            };
            MessageFunction RequestReviveResult_Delegate = (session, wrapper) =>
            {
            	var _wrapper = (MessageWrapper<RequestReviveResultData>)wrapper;
                SC_RequestReviveResult(session, ref _wrapper.message);
                MessageWrapperPool<RequestReviveResultData>.Put(_wrapper);
            };
            MessageFunction MarkTrackingEntityResult_Delegate = (session, wrapper) =>
            {
            	var _wrapper = (MessageWrapper<MarkTrackingEntityResultData>)wrapper;
                SC_MarkTrackingEntityResult(session, ref _wrapper.message);
                MessageWrapperPool<MarkTrackingEntityResultData>.Put(_wrapper);
            };
            MessageFunction NotifyPushEntity_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyPushEntityData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyPushEntity, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyPushEntity(session, _wrapper.message.entityId, _wrapper.message.maxDistance);
                MessageWrapperPool<NotifyPushEntityData>.Put(_wrapper);
            };
            MessageFunction SwitchPhasingResult_Delegate = (session, wrapper) =>
            {
            	var _wrapper = (MessageWrapper<SwitchPhasingResultData>)wrapper;
                SC_SwitchPhasingResult(session, ref _wrapper.message);
                MessageWrapperPool<SwitchPhasingResultData>.Put(_wrapper);
            };
            MessageFunction NotifyStartMiniGame_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyStartMiniGameData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyStartMiniGame, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyStartMiniGame(session, _wrapper.message.type, _wrapper.message.miniGameCid);
                MessageWrapperPool<NotifyStartMiniGameData>.Put(_wrapper);
            };
            MessageFunction NotifyChangeEntityAudio_Delegate = (session, wrapper) =>
            {
            var _wrapper = (MessageWrapper<NotifyChangeEntityAudioData>)wrapper; 
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_NotifyChangeEntityAudio, "Recv->" + _wrapper.message.ToString());
#endif
                SC_NotifyChangeEntityAudio(session, _wrapper.message.entityId, _wrapper.message.audioCid);
                MessageWrapperPool<NotifyChangeEntityAudioData>.Put(_wrapper);
            };
        
            Dictionary<int, INetClientModule.Package2MessageWrapper> retDic = new()
            {
                {NetMessageId.levelLogic_NotifyEnter, (session, package) => {
                	var result = MessageWrapperPool<NotifyEnterData>.Get();
                	result.Init(session, NotifyEnter_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_ReadyToStartResult, (session, package) => {
                	var result = MessageWrapperPool<ReadyToStartResultData>.Get();
                	result.Init(session, ReadyToStartResult_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyStart, (session, package) => {
                	var result = MessageWrapperPool<NotifyStartData>.Get();
                	result.Init(session, NotifyStart_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyLeave, (session, package) => {
                	var result = MessageWrapperPool<NotifyLeaveData>.Get();
                	result.Init(session, NotifyLeave_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_EnterRegionResult, (session, package) => {
                	var result = MessageWrapperPool<EnterRegionResultData>.Get();
                	result.Init(session, EnterRegionResult_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyEnterRegion, (session, package) => {
                	var result = MessageWrapperPool<NotifyEnterRegionData>.Get();
                	result.Init(session, NotifyEnterRegion_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifySyncPosition, (session, package) => {
                	var result = MessageWrapperPool<NotifySyncPositionData>.Get();
                	result.Init(session, NotifySyncPosition_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_UpdateEntities, (session, package) => {
                	var result = MessageWrapperPool<UpdateEntitiesData>.Get();
                	result.Init(session, UpdateEntities_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_InteractResult, (session, package) => {
                	var result = MessageWrapperPool<InteractResultData>.Get();
                	result.Init(session, InteractResult_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_LeaveResult, (session, package) => {
                	var result = MessageWrapperPool<LeaveResultData>.Get();
                	result.Init(session, LeaveResult_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_JumpResult, (session, package) => {
                	var result = MessageWrapperPool<JumpResultData>.Get();
                	result.Init(session, JumpResult_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyBattleSettlement, (session, package) => {
                	var result = MessageWrapperPool<NotifyBattleSettlementData>.Get();
                	result.Init(session, NotifyBattleSettlement_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyShowSpeechBubble, (session, package) => {
                	var result = MessageWrapperPool<NotifyShowSpeechBubbleData>.Get();
                	result.Init(session, NotifyShowSpeechBubble_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_UpdateEntityActivation, (session, package) => {
                	var result = MessageWrapperPool<UpdateEntityActivationData>.Get();
                	result.Init(session, UpdateEntityActivation_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyActivateElevator, (session, package) => {
                	var result = MessageWrapperPool<NotifyActivateElevatorData>.Get();
                	result.Init(session, NotifyActivateElevator_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyStartCameraMotion, (session, package) => {
                	var result = MessageWrapperPool<NotifyStartCameraMotionData>.Get();
                	result.Init(session, NotifyStartCameraMotion_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyEntityObstacleChange, (session, package) => {
                	var result = MessageWrapperPool<NotifyEntityObstacleChangeData>.Get();
                	result.Init(session, NotifyEntityObstacleChange_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyPlayEntityAnimAction, (session, package) => {
                	var result = MessageWrapperPool<NotifyPlayEntityAnimActionData>.Get();
                	result.Init(session, NotifyPlayEntityAnimAction_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyLevelTimeShowChange, (session, package) => {
                	var result = MessageWrapperPool<NotifyLevelTimeShowChangeData>.Get();
                	result.Init(session, NotifyLevelTimeShowChange_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyChangeSceneEffect, (session, package) => {
                	var result = MessageWrapperPool<NotifyChangeSceneEffectData>.Get();
                	result.Init(session, NotifyChangeSceneEffect_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_UpdateEntityRotationY, (session, package) => {
                	var result = MessageWrapperPool<UpdateEntityRotationYData>.Get();
                	result.Init(session, UpdateEntityRotationY_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyActiveCheckPoint, (session, package) => {
                	var result = MessageWrapperPool<NotifyActiveCheckPointData>.Get();
                	result.Init(session, NotifyActiveCheckPoint_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyBuffChange, (session, package) => {
                	var result = MessageWrapperPool<NotifyBuffChangeData>.Get();
                	result.Init(session, NotifyBuffChange_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyCustomBgmChange, (session, package) => {
                	var result = MessageWrapperPool<NotifyCustomBgmChangeData>.Get();
                	result.Init(session, NotifyCustomBgmChange_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyStartStoryDialog, (session, package) => {
                	var result = MessageWrapperPool<NotifyStartStoryDialogData>.Get();
                	result.Init(session, NotifyStartStoryDialog_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_RepoStoryDialogSelectionResult, (session, package) => {
                	var result = MessageWrapperPool<RepoStoryDialogSelectionResultData>.Get();
                	result.Init(session, RepoStoryDialogSelectionResult_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyChangeLevelParam, (session, package) => {
                	var result = MessageWrapperPool<NotifyChangeLevelParamData>.Get();
                	result.Init(session, NotifyChangeLevelParam_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyHeroFollowerChange, (session, package) => {
                	var result = MessageWrapperPool<NotifyHeroFollowerChangeData>.Get();
                	result.Init(session, NotifyHeroFollowerChange_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyChangePlayerCamera, (session, package) => {
                	var result = MessageWrapperPool<NotifyChangePlayerCameraData>.Get();
                	result.Init(session, NotifyChangePlayerCamera_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyChangeWeather, (session, package) => {
                	var result = MessageWrapperPool<NotifyChangeWeatherData>.Get();
                	result.Init(session, NotifyChangeWeather_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_GetMapEntitiesResult, (session, package) => {
                	var result = MessageWrapperPool<GetMapEntitiesResultData>.Get();
                	result.Init(session, GetMapEntitiesResult_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_UpdateEntityAlert, (session, package) => {
                	var result = MessageWrapperPool<UpdateEntityAlertData>.Get();
                	result.Init(session, UpdateEntityAlert_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_UpdateHeroCarrier, (session, package) => {
                	var result = MessageWrapperPool<UpdateHeroCarrierData>.Get();
                	result.Init(session, UpdateHeroCarrier_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyLeaderHeroChanged, (session, package) => {
                	var result = MessageWrapperPool<NotifyLeaderHeroChangedData>.Get();
                	result.Init(session, NotifyLeaderHeroChanged_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyStartItemSubmit, (session, package) => {
                	var result = MessageWrapperPool<NotifyStartItemSubmitData>.Get();
                	result.Init(session, NotifyStartItemSubmit_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_ConfirmItemSubmitResult, (session, package) => {
                	var result = MessageWrapperPool<ConfirmItemSubmitResultData>.Get();
                	result.Init(session, ConfirmItemSubmitResult_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_AcceptQuestResult, (session, package) => {
                	var result = MessageWrapperPool<AcceptQuestResultData>.Get();
                	result.Init(session, AcceptQuestResult_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyDrop, (session, package) => {
                	var result = MessageWrapperPool<NotifyDropData>.Get();
                	result.Init(session, NotifyDrop_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyClearHeroBuff, (session, package) => {
                	var result = MessageWrapperPool<NotifyClearHeroBuffData>.Get();
                	result.Init(session, NotifyClearHeroBuff_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyTeamWipe, (session, package) => {
                	var result = MessageWrapperPool<NotifyTeamWipeData>.Get();
                	result.Init(session, NotifyTeamWipe_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyHeroesAttr, (session, package) => {
                	var result = MessageWrapperPool<NotifyHeroesAttrData>.Get();
                	result.Init(session, NotifyHeroesAttr_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyPlayOrStopEntityEffect, (session, package) => {
                	var result = MessageWrapperPool<NotifyPlayOrStopEntityEffectData>.Get();
                	result.Init(session, NotifyPlayOrStopEntityEffect_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyRevive, (session, package) => {
                	var result = MessageWrapperPool<NotifyReviveData>.Get();
                	result.Init(session, NotifyRevive_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_RequestReviveResult, (session, package) => {
                	var result = MessageWrapperPool<RequestReviveResultData>.Get();
                	result.Init(session, RequestReviveResult_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_MarkTrackingEntityResult, (session, package) => {
                	var result = MessageWrapperPool<MarkTrackingEntityResultData>.Get();
                	result.Init(session, MarkTrackingEntityResult_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyPushEntity, (session, package) => {
                	var result = MessageWrapperPool<NotifyPushEntityData>.Get();
                	result.Init(session, NotifyPushEntity_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_SwitchPhasingResult, (session, package) => {
                	var result = MessageWrapperPool<SwitchPhasingResultData>.Get();
                	result.Init(session, SwitchPhasingResult_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyStartMiniGame, (session, package) => {
                	var result = MessageWrapperPool<NotifyStartMiniGameData>.Get();
                	result.Init(session, NotifyStartMiniGame_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
                {NetMessageId.levelLogic_NotifyChangeEntityAudio, (session, package) => {
                	var result = MessageWrapperPool<NotifyChangeEntityAudioData>.Get();
                	result.Init(session, NotifyChangeEntityAudio_Delegate);
                	result.FromPackage(package);
                	return result;
                }},
            };
            return retDic;
        }
#region Client-side Interface
		/// <summary>
        ///  所有玩家连接成功，初始化数据
        /// </summary>
		protected void SC_NotifyEnter(ISession session, EnterLevelPOD level);
		/// <summary>
        /// 
        /// </summary>
		public void SC_ReadyToStartResult(ISession session, ref ReadyToStartResultData message) 
		{
            _SC_ReadyToStartResult(session, ref message);
		}
		
		public void _SC_ReadyToStartResult(ISession session, ref ReadyToStartResultData message)
		{
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_ReadyToStartResult, "Recv->" + message.ToString());
#endif
			NetProtocolHelper.endCallRequest?.Invoke(NetMessageId.levelLogic_ReadyToStartResult, message.code);
			MsgAsyncAwaiter<ReadyToStartResultData>.Instance.CompleteMsgAwait(ref message);
		}
		
		/// <summary>
        ///  所有玩家Ready
        /// </summary>
		protected void SC_NotifyStart(ISession session);
		/// <summary>
        ///  通知玩家退出关卡，outRegionCid：离开关卡后到达的地方的regionCid，outPortalMcid：传送们mcid，anotherLevelCid：另一个关卡的cid，客户端处理关卡到关卡
        /// </summary>
		protected void SC_NotifyLeave(ISession session, int outRegionCid, int outPortalMcid, int anotherLevelCid);
		/// <summary>
        /// 地图UI切换地区的回复
        /// </summary>
		public void SC_EnterRegionResult(ISession session, ref EnterRegionResultData message) 
		{
            _SC_EnterRegionResult(session, ref message);
		}
		
		public void _SC_EnterRegionResult(ISession session, ref EnterRegionResultData message)
		{
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_EnterRegionResult, "Recv->" + message.ToString());
#endif
			NetProtocolHelper.endCallRequest?.Invoke(NetMessageId.levelLogic_EnterRegionResult, message.code);
			MsgAsyncAwaiter<EnterRegionResultData>.Instance.CompleteMsgAwait(ref message);
		}
		
		/// <summary>
        /// 
        /// </summary>
		protected void SC_NotifyEnterRegion(ISession session, LevelRegionPOD region);
		/// <summary>
        /// dirType为1表示移动时朝向一直不变，为2表示dir.y不变
        /// </summary>
		protected void SC_NotifySyncPosition(ISession session, LevelMoveReason reason, int entityId, LevelEntityType entityType, float x, float y, float z, float speedRatio, byte dirType);
		/// <summary>
        /// 
        /// </summary>
		protected void SC_UpdateEntities(ISession session, List<LevelEntityPOD> modifiedList, List<int> removedList, bool isPlayDieWhenRemove);
		/// <summary>
        /// 
        /// </summary>
		public void SC_InteractResult(ISession session, ref InteractResultData message) 
		{
            _SC_InteractResult(session, ref message);
		}
		
		public void _SC_InteractResult(ISession session, ref InteractResultData message)
		{
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_InteractResult, "Recv->" + message.ToString());
#endif
			NetProtocolHelper.endCallRequest?.Invoke(NetMessageId.levelLogic_InteractResult, message.code);
			MsgAsyncAwaiter<InteractResultData>.Instance.CompleteMsgAwait(ref message);
		}
		
		/// <summary>
        /// 
        /// </summary>
		public void SC_LeaveResult(ISession session, ref LeaveResultData message) 
		{
            _SC_LeaveResult(session, ref message);
		}
		
		public void _SC_LeaveResult(ISession session, ref LeaveResultData message)
		{
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_LeaveResult, "Recv->" + message.ToString());
#endif
			NetProtocolHelper.endCallRequest?.Invoke(NetMessageId.levelLogic_LeaveResult, message.code);
			MsgAsyncAwaiter<LeaveResultData>.Instance.CompleteMsgAwait(ref message);
		}
		
		/// <summary>
        /// 
        /// </summary>
		public void SC_JumpResult(ISession session, ref JumpResultData message) 
		{
            _SC_JumpResult(session, ref message);
		}
		
		public void _SC_JumpResult(ISession session, ref JumpResultData message)
		{
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_JumpResult, "Recv->" + message.ToString());
#endif
			NetProtocolHelper.endCallRequest?.Invoke(NetMessageId.levelLogic_JumpResult, message.code);
			MsgAsyncAwaiter<JumpResultData>.Instance.CompleteMsgAwait(ref message);
		}
		
		/// <summary>
        /// 通知战斗结算
        /// </summary>
		protected void SC_NotifyBattleSettlement(ISession session, BattleSettlementPOD settlementPOD);
		/// <summary>
        /// 显示对话气泡
        /// </summary>
		protected void SC_NotifyShowSpeechBubble(ISession session, int entityId, int bubbleGroupId, List<int> validBubbleIds);
		/// <summary>
        /// 切换实体激活状态
        /// </summary>
		protected void SC_UpdateEntityActivation(ISession session, List<int> entityIdList, bool isActive, int animActionId, bool isSetRotation, int rotationY);
		/// <summary>
        /// 通知电梯开始或停止运动
        /// </summary>
		protected void SC_NotifyActivateElevator(ISession session, int elevatorEntityId, int targetFloor, bool isRidingMode, bool isMoveState);
		/// <summary>
        /// 通知客户端开始播放镜头动画
        /// </summary>
		protected void SC_NotifyStartCameraMotion(ISession session, int levelScreenSwitchCid);
		/// <summary>
        /// 阻挡生效状态变化
        /// </summary>
		protected void SC_NotifyEntityObstacleChange(ISession session, List<int> entityIds, bool isObstacleActive);
		/// <summary>
        /// 实体播放动作动画
        /// </summary>
		protected void SC_NotifyPlayEntityAnimAction(ISession session, List<int> entityIds, int actionId);
		/// <summary>
        /// 更新关卡时间显示
        /// </summary>
		protected void SC_NotifyLevelTimeShowChange(ISession session, int timeHour);
		/// <summary>
        /// 改变场景特效（天气等）
        /// </summary>
		protected void SC_NotifyChangeSceneEffect(ISession session, int entityId, int sceneEffectId, bool isAdd);
		/// <summary>
        /// 更新实体朝向
        /// </summary>
		protected void SC_UpdateEntityRotationY(ISession session, int entityId, LevelEntityType entityType, int rotationY);
		/// <summary>
        /// 通知激活或关闭存档点
        /// </summary>
		protected void SC_NotifyActiveCheckPoint(ISession session, int entityId, bool isActive);
		/// <summary>
        /// 通知buff变化
        /// </summary>
		protected void SC_NotifyBuffChange(ISession session, List<LevelBuffChangePOD> changes);
		/// <summary>
        /// 通知策划自定义的，优先级最高的BGM的变化
        /// </summary>
		protected void SC_NotifyCustomBgmChange(ISession session, int bgmAudioCid);
		/// <summary>
        /// 开启故事（npc对话）表现
        /// </summary>
		protected void SC_NotifyStartStoryDialog(ISession session, int cid, int jumpCid, int entityId);
		/// <summary>
        /// 对话选项Response
        /// </summary>
		public void SC_RepoStoryDialogSelectionResult(ISession session, ref RepoStoryDialogSelectionResultData message) 
		{
            _SC_RepoStoryDialogSelectionResult(session, ref message);
		}
		
		public void _SC_RepoStoryDialogSelectionResult(ISession session, ref RepoStoryDialogSelectionResultData message)
		{
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_RepoStoryDialogSelectionResult, "Recv->" + message.ToString());
#endif
			NetProtocolHelper.endCallRequest?.Invoke(NetMessageId.levelLogic_RepoStoryDialogSelectionResult, message.code);
			MsgAsyncAwaiter<RepoStoryDialogSelectionResultData>.Instance.CompleteMsgAwait(ref message);
		}
		
		/// <summary>
        /// 通知改变关卡参数，直接按照key覆盖value
        /// </summary>
		protected void SC_NotifyChangeLevelParam(ISession session, int key, int value);
		/// <summary>
        /// 通知跟随英雄的实体变化
        /// </summary>
		protected void SC_NotifyHeroFollowerChange(ISession session, int id);
		/// <summary>
        /// 通知改变当前客户端玩家的相机参数，0代表还原
        /// </summary>
		protected void SC_NotifyChangePlayerCamera(ISession session, int cameraCid);
		/// <summary>
        /// 通知天气变化
        /// </summary>
		protected void SC_NotifyChangeWeather(ISession session, int id, int weatherType);
		/// <summary>
        /// 
        /// </summary>
		public void SC_GetMapEntitiesResult(ISession session, ref GetMapEntitiesResultData message) 
		{
            _SC_GetMapEntitiesResult(session, ref message);
		}
		
		public void _SC_GetMapEntitiesResult(ISession session, ref GetMapEntitiesResultData message)
		{
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_GetMapEntitiesResult, "Recv->" + message.ToString());
#endif
			NetProtocolHelper.endCallRequest?.Invoke(NetMessageId.levelLogic_GetMapEntitiesResult, message.code);
			MsgAsyncAwaiter<GetMapEntitiesResultData>.Instance.CompleteMsgAwait(ref message);
		}
		
		/// <summary>
        /// 通知怪物警戒值变化，alertValue(0-100)
        /// </summary>
		protected void SC_UpdateEntityAlert(ISession session, int entityId, int targetEntityId, int alertValue);
		/// <summary>
        /// 更新载具，如果没有载具id为0
        /// </summary>
		protected void SC_UpdateHeroCarrier(ISession session, int heroEntityId, int entityId, bool isRemoved);
		/// <summary>
        /// 更新队长
        /// </summary>
		protected void SC_NotifyLeaderHeroChanged(ISession session, int heroEntityId, LevelHeroPOD leaderHeroPOD);
		/// <summary>
        /// 
        /// </summary>
		protected void SC_NotifyStartItemSubmit(ISession session, int itemSubmitCid);
		/// <summary>
        /// 
        /// </summary>
		public void SC_ConfirmItemSubmitResult(ISession session, ref ConfirmItemSubmitResultData message) 
		{
            _SC_ConfirmItemSubmitResult(session, ref message);
		}
		
		public void _SC_ConfirmItemSubmitResult(ISession session, ref ConfirmItemSubmitResultData message)
		{
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_ConfirmItemSubmitResult, "Recv->" + message.ToString());
#endif
			NetProtocolHelper.endCallRequest?.Invoke(NetMessageId.levelLogic_ConfirmItemSubmitResult, message.code);
			MsgAsyncAwaiter<ConfirmItemSubmitResultData>.Instance.CompleteMsgAwait(ref message);
		}
		
		/// <summary>
        /// 
        /// </summary>
		public void SC_AcceptQuestResult(ISession session, ref AcceptQuestResultData message) 
		{
            _SC_AcceptQuestResult(session, ref message);
		}
		
		public void _SC_AcceptQuestResult(ISession session, ref AcceptQuestResultData message)
		{
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_AcceptQuestResult, "Recv->" + message.ToString());
#endif
			NetProtocolHelper.endCallRequest?.Invoke(NetMessageId.levelLogic_AcceptQuestResult, message.code);
			MsgAsyncAwaiter<AcceptQuestResultData>.Instance.CompleteMsgAwait(ref message);
		}
		
		/// <summary>
        /// 
        /// </summary>
		protected void SC_NotifyDrop(ISession session, int srcEntityId, List<ItemShowPOD> items);
		/// <summary>
        /// 
        /// </summary>
		protected void SC_NotifyClearHeroBuff(ISession session, long pid, long heroId);
		/// <summary>
        /// 
        /// </summary>
		protected void SC_NotifyTeamWipe(ISession session, long pid, long leaderHeroId);
		/// <summary>
        /// 
        /// </summary>
		protected void SC_NotifyHeroesAttr(ISession session, long pid, List<LevelHeroAttrSyncPOD> heroAttrs, AttrChangeReason reason);
		/// <summary>
        /// 
        /// </summary>
		protected void SC_NotifyPlayOrStopEntityEffect(ISession session, int singleEntityId, List<int> multiEntityIds, int effectResCid, int bindPointCid, bool isAdd);
		/// <summary>
        /// 玩家从团灭复活，复活所有英雄（视需求看以后要不要做单英雄复活）
        /// </summary>
		protected void SC_NotifyRevive(ISession session, long pid);
		/// <summary>
        /// 
        /// </summary>
		public void SC_RequestReviveResult(ISession session, ref RequestReviveResultData message) 
		{
            _SC_RequestReviveResult(session, ref message);
		}
		
		public void _SC_RequestReviveResult(ISession session, ref RequestReviveResultData message)
		{
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_RequestReviveResult, "Recv->" + message.ToString());
#endif
			NetProtocolHelper.endCallRequest?.Invoke(NetMessageId.levelLogic_RequestReviveResult, message.code);
			MsgAsyncAwaiter<RequestReviveResultData>.Instance.CompleteMsgAwait(ref message);
		}
		
		/// <summary>
        /// 
        /// </summary>
		public void SC_MarkTrackingEntityResult(ISession session, ref MarkTrackingEntityResultData message) 
		{
            _SC_MarkTrackingEntityResult(session, ref message);
		}
		
		public void _SC_MarkTrackingEntityResult(ISession session, ref MarkTrackingEntityResultData message)
		{
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_MarkTrackingEntityResult, "Recv->" + message.ToString());
#endif
			NetProtocolHelper.endCallRequest?.Invoke(NetMessageId.levelLogic_MarkTrackingEntityResult, message.code);
			MsgAsyncAwaiter<MarkTrackingEntityResultData>.Instance.CompleteMsgAwait(ref message);
		}
		
		/// <summary>
        /// 
        /// </summary>
		protected void SC_NotifyPushEntity(ISession session, int entityId, int maxDistance);
		/// <summary>
        /// 
        /// </summary>
		public void SC_SwitchPhasingResult(ISession session, ref SwitchPhasingResultData message) 
		{
            _SC_SwitchPhasingResult(session, ref message);
		}
		
		public void _SC_SwitchPhasingResult(ISession session, ref SwitchPhasingResultData message)
		{
#if ENABLE_NET_LOG || UNITY_EDITOR
            NetProtocolHelper.ClientLog(NetMessageId.levelLogic_SwitchPhasingResult, "Recv->" + message.ToString());
#endif
			NetProtocolHelper.endCallRequest?.Invoke(NetMessageId.levelLogic_SwitchPhasingResult, message.code);
			MsgAsyncAwaiter<SwitchPhasingResultData>.Instance.CompleteMsgAwait(ref message);
		}
		
		/// <summary>
        /// 
        /// </summary>
		protected void SC_NotifyStartMiniGame(ISession session, LevelMiniGameType type, int miniGameCid);
		/// <summary>
        /// 
        /// </summary>
		protected void SC_NotifyChangeEntityAudio(ISession session, int entityId, int audioCid);
#endregion
#region Server-side Interface
		/// <summary>
        /// 
        /// </summary>
    	public UniTask<ReadyToStartResultData> CS_ReadyToStart()
        {
            return _CS_ReadyToStart();
        }
        
        public UniTask<ReadyToStartResultData> _CS_ReadyToStart()
        {
        	ISession session = GetSession();
        	if(session == null) return UniTask.FromResult(default(ReadyToStartResultData));
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.levelLogic_ReadyToStart, "Send->"+"LevelLogic.CS_ReadyToStart { "
				+" }");
#endif
        	UniTask<ReadyToStartResultData> task = MsgAsyncAwaiter<ReadyToStartResultData>.Instance.AddMsgAwait();
        	session.SendPack(Pack_for_ReadyToStart());
        	NetProtocolHelper.beginCallRequest?.Invoke(NetMessageId.levelLogic_ReadyToStartResult);
			return task;
        }
		
		public static SendPackage Pack_for_ReadyToStart() 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.levelLogic_ReadyToStart;
			si_p.StartWrite();
			return si_p;
		}
		/// <summary>
        /// 地图UI切换地区
        /// </summary>
    	public UniTask<EnterRegionResultData> CS_EnterRegion(int regionCid, int portalId)
        {
            return _CS_EnterRegion(regionCid, portalId);
        }
        
        public UniTask<EnterRegionResultData> _CS_EnterRegion(int regionCid, int portalId)
        {
        	ISession session = GetSession();
        	if(session == null) return UniTask.FromResult(default(EnterRegionResultData));
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.levelLogic_EnterRegion, "Send->"+"LevelLogic.CS_EnterRegion { "
				+ "regionCid="
				+ regionCid
				+ ", portalId="
				+ portalId
				+" }");
#endif
        	UniTask<EnterRegionResultData> task = MsgAsyncAwaiter<EnterRegionResultData>.Instance.AddMsgAwait();
        	session.SendPack(Pack_for_EnterRegion(regionCid, portalId));
        	NetProtocolHelper.beginCallRequest?.Invoke(NetMessageId.levelLogic_EnterRegionResult);
			return task;
        }
		
		public static SendPackage Pack_for_EnterRegion(int regionCid, int portalId) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.levelLogic_EnterRegion;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_int(regionCid);
			_out.Write_int(portalId);
			return si_p;
		}
		/// <summary>
        /// 
        /// </summary>
    	public bool CS_Move(float x, float y, float z) 
    	{
    		return _CS_Move(x, y, z);
    	}
    	public bool _CS_Move(float x, float y, float z)
        {
        	ISession session = GetSession();
        	if(session == null) return false;
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.levelLogic_Move, "Send->"+"LevelLogic.CS_Move { "
				+ "x="
				+ x
				+ ", y="
				+ y
				+ ", z="
				+ z
				+" }");
#endif
        	return session.SendPack(Pack_for_Move(x, y, z));
        }
		
		public static SendPackage Pack_for_Move(float x, float y, float z) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.levelLogic_Move;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_float(x);
			_out.Write_float(y);
			_out.Write_float(z);
			return si_p;
		}
		/// <summary>
        /// 
        /// </summary>
    	public UniTask<InteractResultData> CS_Interact(int entityId)
        {
            return _CS_Interact(entityId);
        }
        
        public UniTask<InteractResultData> _CS_Interact(int entityId)
        {
        	ISession session = GetSession();
        	if(session == null) return UniTask.FromResult(default(InteractResultData));
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.levelLogic_Interact, "Send->"+"LevelLogic.CS_Interact { "
				+ "entityId="
				+ entityId
				+" }");
#endif
        	UniTask<InteractResultData> task = MsgAsyncAwaiter<InteractResultData>.Instance.AddMsgAwait();
        	session.SendPack(Pack_for_Interact(entityId));
        	NetProtocolHelper.beginCallRequest?.Invoke(NetMessageId.levelLogic_InteractResult);
			return task;
        }
		
		public static SendPackage Pack_for_Interact(int entityId) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.levelLogic_Interact;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_int(entityId);
			return si_p;
		}
		/// <summary>
        /// 离开关卡，outRegionCid：离开关卡后到达的地方的regionCid，outPortalMcid：传送们mcid，anotherLevelCid：另一个关卡的cid，中转参数，notify以后客户端处理关卡到关卡
        /// </summary>
    	public UniTask<LeaveResultData> CS_Leave(int outRegionCid, int outPortalMcid, int anotherLevelCid)
        {
            return _CS_Leave(outRegionCid, outPortalMcid, anotherLevelCid);
        }
        
        public UniTask<LeaveResultData> _CS_Leave(int outRegionCid, int outPortalMcid, int anotherLevelCid)
        {
        	ISession session = GetSession();
        	if(session == null) return UniTask.FromResult(default(LeaveResultData));
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.levelLogic_Leave, "Send->"+"LevelLogic.CS_Leave { "
				+ "outRegionCid="
				+ outRegionCid
				+ ", outPortalMcid="
				+ outPortalMcid
				+ ", anotherLevelCid="
				+ anotherLevelCid
				+" }");
#endif
        	UniTask<LeaveResultData> task = MsgAsyncAwaiter<LeaveResultData>.Instance.AddMsgAwait();
        	session.SendPack(Pack_for_Leave(outRegionCid, outPortalMcid, anotherLevelCid));
        	NetProtocolHelper.beginCallRequest?.Invoke(NetMessageId.levelLogic_LeaveResult);
			return task;
        }
		
		public static SendPackage Pack_for_Leave(int outRegionCid, int outPortalMcid, int anotherLevelCid) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.levelLogic_Leave;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_int(outRegionCid);
			_out.Write_int(outPortalMcid);
			_out.Write_int(anotherLevelCid);
			return si_p;
		}
		/// <summary>
        /// 跳跃
        /// </summary>
    	public UniTask<JumpResultData> CS_Jump(int entityId, float dirX, float dirZ)
        {
            return _CS_Jump(entityId, dirX, dirZ);
        }
        
        public UniTask<JumpResultData> _CS_Jump(int entityId, float dirX, float dirZ)
        {
        	ISession session = GetSession();
        	if(session == null) return UniTask.FromResult(default(JumpResultData));
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.levelLogic_Jump, "Send->"+"LevelLogic.CS_Jump { "
				+ "entityId="
				+ entityId
				+ ", dirX="
				+ dirX
				+ ", dirZ="
				+ dirZ
				+" }");
#endif
        	UniTask<JumpResultData> task = MsgAsyncAwaiter<JumpResultData>.Instance.AddMsgAwait();
        	session.SendPack(Pack_for_Jump(entityId, dirX, dirZ));
        	NetProtocolHelper.beginCallRequest?.Invoke(NetMessageId.levelLogic_JumpResult);
			return task;
        }
		
		public static SendPackage Pack_for_Jump(int entityId, float dirX, float dirZ) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.levelLogic_Jump;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_int(entityId);
			_out.Write_float(dirX);
			_out.Write_float(dirZ);
			return si_p;
		}
		/// <summary>
        /// 改变寻路模式：物理/网格，xyz代表离开物理寻路模式，切回网格模式时所处的位置
        /// </summary>
    	public bool CS_SwitchPhysicNavMode(bool isPhysical, float x, float y, float z) 
    	{
    		return _CS_SwitchPhysicNavMode(isPhysical, x, y, z);
    	}
    	public bool _CS_SwitchPhysicNavMode(bool isPhysical, float x, float y, float z)
        {
        	ISession session = GetSession();
        	if(session == null) return false;
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.levelLogic_SwitchPhysicNavMode, "Send->"+"LevelLogic.CS_SwitchPhysicNavMode { "
				+ "isPhysical="
				+ isPhysical
				+ ", x="
				+ x
				+ ", y="
				+ y
				+ ", z="
				+ z
				+" }");
#endif
        	return session.SendPack(Pack_for_SwitchPhysicNavMode(isPhysical, x, y, z));
        }
		
		public static SendPackage Pack_for_SwitchPhysicNavMode(bool isPhysical, float x, float y, float z) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.levelLogic_SwitchPhysicNavMode;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_boolean(isPhysical);
			_out.Write_float(x);
			_out.Write_float(y);
			_out.Write_float(z);
			return si_p;
		}
		/// <summary>
        /// 触发陷阱
        /// </summary>
    	public bool CS_TriggerInEntityState(int entityId, int state) 
    	{
    		return _CS_TriggerInEntityState(entityId, state);
    	}
    	public bool _CS_TriggerInEntityState(int entityId, int state)
        {
        	ISession session = GetSession();
        	if(session == null) return false;
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.levelLogic_TriggerInEntityState, "Send->"+"LevelLogic.CS_TriggerInEntityState { "
				+ "entityId="
				+ entityId
				+ ", state="
				+ state
				+" }");
#endif
        	return session.SendPack(Pack_for_TriggerInEntityState(entityId, state));
        }
		
		public static SendPackage Pack_for_TriggerInEntityState(int entityId, int state) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.levelLogic_TriggerInEntityState;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_int(entityId);
			_out.Write_int(state);
			return si_p;
		}
		/// <summary>
        /// 对话选项上报，selectionIndexes玩家选择的选项索引
        /// </summary>
    	public UniTask<RepoStoryDialogSelectionResultData> CS_RepoStoryDialogSelection(List<int> selectionIndexes)
        {
            return _CS_RepoStoryDialogSelection(selectionIndexes);
        }
        
        public UniTask<RepoStoryDialogSelectionResultData> _CS_RepoStoryDialogSelection(List<int> selectionIndexes)
        {
        	ISession session = GetSession();
        	if(session == null) return UniTask.FromResult(default(RepoStoryDialogSelectionResultData));
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.levelLogic_RepoStoryDialogSelection, "Send->"+"LevelLogic.CS_RepoStoryDialogSelection { "
				+ "selectionIndexes="
				+ selectionIndexes.ToString<int>()
				+" }");
#endif
        	UniTask<RepoStoryDialogSelectionResultData> task = MsgAsyncAwaiter<RepoStoryDialogSelectionResultData>.Instance.AddMsgAwait();
        	session.SendPack(Pack_for_RepoStoryDialogSelection(selectionIndexes));
        	NetProtocolHelper.beginCallRequest?.Invoke(NetMessageId.levelLogic_RepoStoryDialogSelectionResult);
			return task;
        }
		
		public static SendPackage Pack_for_RepoStoryDialogSelection(List<int> selectionIndexes) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.levelLogic_RepoStoryDialogSelection;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_list_int(selectionIndexes);	
			return si_p;
		}
		/// <summary>
        /// 
        /// </summary>
    	public UniTask<GetMapEntitiesResultData> CS_GetMapEntities(int regionCid)
        {
            return _CS_GetMapEntities(regionCid);
        }
        
        public UniTask<GetMapEntitiesResultData> _CS_GetMapEntities(int regionCid)
        {
        	ISession session = GetSession();
        	if(session == null) return UniTask.FromResult(default(GetMapEntitiesResultData));
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.levelLogic_GetMapEntities, "Send->"+"LevelLogic.CS_GetMapEntities { "
				+ "regionCid="
				+ regionCid
				+" }");
#endif
        	UniTask<GetMapEntitiesResultData> task = MsgAsyncAwaiter<GetMapEntitiesResultData>.Instance.AddMsgAwait();
        	session.SendPack(Pack_for_GetMapEntities(regionCid));
        	NetProtocolHelper.beginCallRequest?.Invoke(NetMessageId.levelLogic_GetMapEntitiesResult);
			return task;
        }
		
		public static SendPackage Pack_for_GetMapEntities(int regionCid) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.levelLogic_GetMapEntities;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_int(regionCid);
			return si_p;
		}
		/// <summary>
        /// 
        /// </summary>
    	public bool CS_TeleportToEntity(int entityId) 
    	{
    		return _CS_TeleportToEntity(entityId);
    	}
    	public bool _CS_TeleportToEntity(int entityId)
        {
        	ISession session = GetSession();
        	if(session == null) return false;
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.levelLogic_TeleportToEntity, "Send->"+"LevelLogic.CS_TeleportToEntity { "
				+ "entityId="
				+ entityId
				+" }");
#endif
        	return session.SendPack(Pack_for_TeleportToEntity(entityId));
        }
		
		public static SendPackage Pack_for_TeleportToEntity(int entityId) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.levelLogic_TeleportToEntity;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_int(entityId);
			return si_p;
		}
		/// <summary>
        /// 
        /// </summary>
    	public UniTask<ConfirmItemSubmitResultData> CS_ConfirmItemSubmit(List<long> itemIdList)
        {
            return _CS_ConfirmItemSubmit(itemIdList);
        }
        
        public UniTask<ConfirmItemSubmitResultData> _CS_ConfirmItemSubmit(List<long> itemIdList)
        {
        	ISession session = GetSession();
        	if(session == null) return UniTask.FromResult(default(ConfirmItemSubmitResultData));
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.levelLogic_ConfirmItemSubmit, "Send->"+"LevelLogic.CS_ConfirmItemSubmit { "
				+ "itemIdList="
				+ itemIdList.ToString<long>()
				+" }");
#endif
        	UniTask<ConfirmItemSubmitResultData> task = MsgAsyncAwaiter<ConfirmItemSubmitResultData>.Instance.AddMsgAwait();
        	session.SendPack(Pack_for_ConfirmItemSubmit(itemIdList));
        	NetProtocolHelper.beginCallRequest?.Invoke(NetMessageId.levelLogic_ConfirmItemSubmitResult);
			return task;
        }
		
		public static SendPackage Pack_for_ConfirmItemSubmit(List<long> itemIdList) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.levelLogic_ConfirmItemSubmit;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_list_long(itemIdList);	
			return si_p;
		}
		/// <summary>
        /// 
        /// </summary>
    	public UniTask<AcceptQuestResultData> CS_AcceptQuest(int questCid)
        {
            return _CS_AcceptQuest(questCid);
        }
        
        public UniTask<AcceptQuestResultData> _CS_AcceptQuest(int questCid)
        {
        	ISession session = GetSession();
        	if(session == null) return UniTask.FromResult(default(AcceptQuestResultData));
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.levelLogic_AcceptQuest, "Send->"+"LevelLogic.CS_AcceptQuest { "
				+ "questCid="
				+ questCid
				+" }");
#endif
        	UniTask<AcceptQuestResultData> task = MsgAsyncAwaiter<AcceptQuestResultData>.Instance.AddMsgAwait();
        	session.SendPack(Pack_for_AcceptQuest(questCid));
        	NetProtocolHelper.beginCallRequest?.Invoke(NetMessageId.levelLogic_AcceptQuestResult);
			return task;
        }
		
		public static SendPackage Pack_for_AcceptQuest(int questCid) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.levelLogic_AcceptQuest;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_int(questCid);
			return si_p;
		}
		/// <summary>
        /// 
        /// </summary>
    	public UniTask<RequestReviveResultData> CS_RequestRevive()
        {
            return _CS_RequestRevive();
        }
        
        public UniTask<RequestReviveResultData> _CS_RequestRevive()
        {
        	ISession session = GetSession();
        	if(session == null) return UniTask.FromResult(default(RequestReviveResultData));
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.levelLogic_RequestRevive, "Send->"+"LevelLogic.CS_RequestRevive { "
				+" }");
#endif
        	UniTask<RequestReviveResultData> task = MsgAsyncAwaiter<RequestReviveResultData>.Instance.AddMsgAwait();
        	session.SendPack(Pack_for_RequestRevive());
        	NetProtocolHelper.beginCallRequest?.Invoke(NetMessageId.levelLogic_RequestReviveResult);
			return task;
        }
		
		public static SendPackage Pack_for_RequestRevive() 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.levelLogic_RequestRevive;
			si_p.StartWrite();
			return si_p;
		}
		/// <summary>
        /// 
        /// </summary>
    	public UniTask<MarkTrackingEntityResultData> CS_MarkTrackingEntity(int entityId)
        {
            return _CS_MarkTrackingEntity(entityId);
        }
        
        public UniTask<MarkTrackingEntityResultData> _CS_MarkTrackingEntity(int entityId)
        {
        	ISession session = GetSession();
        	if(session == null) return UniTask.FromResult(default(MarkTrackingEntityResultData));
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.levelLogic_MarkTrackingEntity, "Send->"+"LevelLogic.CS_MarkTrackingEntity { "
				+ "entityId="
				+ entityId
				+" }");
#endif
        	UniTask<MarkTrackingEntityResultData> task = MsgAsyncAwaiter<MarkTrackingEntityResultData>.Instance.AddMsgAwait();
        	session.SendPack(Pack_for_MarkTrackingEntity(entityId));
        	NetProtocolHelper.beginCallRequest?.Invoke(NetMessageId.levelLogic_MarkTrackingEntityResult);
			return task;
        }
		
		public static SendPackage Pack_for_MarkTrackingEntity(int entityId) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.levelLogic_MarkTrackingEntity;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_int(entityId);
			return si_p;
		}
		/// <summary>
        /// 
        /// </summary>
    	public bool CS_PushEntityArrive(int entityId, int x, int y, int z) 
    	{
    		return _CS_PushEntityArrive(entityId, x, y, z);
    	}
    	public bool _CS_PushEntityArrive(int entityId, int x, int y, int z)
        {
        	ISession session = GetSession();
        	if(session == null) return false;
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.levelLogic_PushEntityArrive, "Send->"+"LevelLogic.CS_PushEntityArrive { "
				+ "entityId="
				+ entityId
				+ ", x="
				+ x
				+ ", y="
				+ y
				+ ", z="
				+ z
				+" }");
#endif
        	return session.SendPack(Pack_for_PushEntityArrive(entityId, x, y, z));
        }
		
		public static SendPackage Pack_for_PushEntityArrive(int entityId, int x, int y, int z) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.levelLogic_PushEntityArrive;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_int(entityId);
			_out.Write_int(x);
			_out.Write_int(y);
			_out.Write_int(z);
			return si_p;
		}
		/// <summary>
        /// 
        /// </summary>
    	public UniTask<SwitchPhasingResultData> CS_SwitchPhasing(GameScenePhasing phasing, int mainPhasingPosX, int mainPhasingPosY, int mainPhasingPosZ)
        {
            return _CS_SwitchPhasing(phasing, mainPhasingPosX, mainPhasingPosY, mainPhasingPosZ);
        }
        
        public UniTask<SwitchPhasingResultData> _CS_SwitchPhasing(GameScenePhasing phasing, int mainPhasingPosX, int mainPhasingPosY, int mainPhasingPosZ)
        {
        	ISession session = GetSession();
        	if(session == null) return UniTask.FromResult(default(SwitchPhasingResultData));
#if ENABLE_NET_LOG || UNITY_EDITOR
			NetProtocolHelper.ClientLog(NetMessageId.levelLogic_SwitchPhasing, "Send->"+"LevelLogic.CS_SwitchPhasing { "
				+ "phasing="
				+ phasing
				+ ", mainPhasingPosX="
				+ mainPhasingPosX
				+ ", mainPhasingPosY="
				+ mainPhasingPosY
				+ ", mainPhasingPosZ="
				+ mainPhasingPosZ
				+" }");
#endif
        	UniTask<SwitchPhasingResultData> task = MsgAsyncAwaiter<SwitchPhasingResultData>.Instance.AddMsgAwait();
        	session.SendPack(Pack_for_SwitchPhasing(phasing, mainPhasingPosX, mainPhasingPosY, mainPhasingPosZ));
        	NetProtocolHelper.beginCallRequest?.Invoke(NetMessageId.levelLogic_SwitchPhasingResult);
			return task;
        }
		
		public static SendPackage Pack_for_SwitchPhasing(GameScenePhasing phasing, int mainPhasingPosX, int mainPhasingPosY, int mainPhasingPosZ) 
		{
			SendPackage si_p = NetProtocolHelper.GetSendPackage();
			si_p.Header.Messagid = NetMessageId.levelLogic_SwitchPhasing;
			si_p.StartWrite();
			SOutputStream _out = si_p.OutputStream;
			_out.Write_byte((sbyte)phasing);
			_out.Write_int(mainPhasingPosX);
			_out.Write_int(mainPhasingPosY);
			_out.Write_int(mainPhasingPosZ);
			return si_p;
		}
#endregion
#region Messages
        public struct NotifyEnterData : IReceiveMessage {
	        public EnterLevelPOD level;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                level = _in.HasRemaining() ? _in.Read_pod<EnterLevelPOD>(EnterLevelPOD.DynamicFactory) : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyEnter;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyEnter"+ ", level="+ level;
            }
        }
        public struct ReadyToStartResultData : IReceiveMessage {
        	private int? _code;
        	public int code {get{return _code == null ? -1 : (int)_code;}private set{_code = value;}}
            public bool IsFail => _code != null && _code != 0;
            public bool IsSuccess =>_code != null && _code == 0;
            public bool IsCanceled => _code == null;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                code = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_ReadyToStartResult;}
            
            public override string ToString()
            {
                return "LevelLogic.ReadyToStartResult"+ ", code="+ code;
            }
        }
        public struct NotifyStartData : IReceiveMessage {
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyStart;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyStart";
            }
        }
        public struct NotifyLeaveData : IReceiveMessage {
	        public int outRegionCid;
	        public int outPortalMcid;
	        public int anotherLevelCid;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                outRegionCid = _in.HasRemaining() ? _in.Read_int() : default;
                outPortalMcid = _in.HasRemaining() ? _in.Read_int() : default;
                anotherLevelCid = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyLeave;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyLeave"+ ", outRegionCid="+ outRegionCid+ ", outPortalMcid="+ outPortalMcid+ ", anotherLevelCid="+ anotherLevelCid;
            }
        }
        public struct EnterRegionResultData : IReceiveMessage {
        	private int? _code;
        	public int code {get{return _code == null ? -1 : (int)_code;}private set{_code = value;}}
	        public int regionCid;
	        public int portalId;
            public bool IsFail => _code != null && _code != 0;
            public bool IsSuccess =>_code != null && _code == 0;
            public bool IsCanceled => _code == null;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                code = _in.HasRemaining() ? _in.Read_int() : default;
                regionCid = _in.HasRemaining() ? _in.Read_int() : default;
                portalId = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_EnterRegionResult;}
            
            public override string ToString()
            {
                return "LevelLogic.EnterRegionResult"+ ", code="+ code+ ", regionCid="+ regionCid+ ", portalId="+ portalId;
            }
        }
        public struct NotifyEnterRegionData : IReceiveMessage {
	        public LevelRegionPOD region;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                region = _in.HasRemaining() ? _in.Read_pod<LevelRegionPOD>(LevelRegionPOD.DynamicFactory) : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyEnterRegion;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyEnterRegion"+ ", region="+ region;
            }
        }
        public struct NotifySyncPositionData : IReceiveMessage {
	        public LevelMoveReason reason;
	        public int entityId;
	        public LevelEntityType entityType;
	        public float x;
	        public float y;
	        public float z;
	        public float speedRatio;
	        public byte dirType;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                reason = _in.HasRemaining() ? (LevelMoveReason)_in.Read_byte() : default;
                entityId = _in.HasRemaining() ? _in.Read_int() : default;
                entityType = _in.HasRemaining() ? (LevelEntityType)_in.Read_byte() : default;
                x = _in.HasRemaining() ? _in.Read_float() : default;
                y = _in.HasRemaining() ? _in.Read_float() : default;
                z = _in.HasRemaining() ? _in.Read_float() : default;
                speedRatio = _in.HasRemaining() ? _in.Read_float() : default;
                dirType = _in.HasRemaining() ? _in.Read_ubyte() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifySyncPosition;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifySyncPosition"+ ", reason="+ reason+ ", entityId="+ entityId+ ", entityType="+ entityType+ ", x="+ x+ ", y="+ y+ ", z="+ z+ ", speedRatio="+ speedRatio+ ", dirType="+ dirType;
            }
        }
        public struct UpdateEntitiesData : IReceiveMessage {
	        public List<LevelEntityPOD> modifiedList;
	        public List<int> removedList;
	        public bool isPlayDieWhenRemove;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                modifiedList = _in.HasRemaining() ? _in.Read_list_pod<LevelEntityPOD>(LevelEntityPOD.DynamicFactory) : default;
                removedList = _in.HasRemaining() ? _in.Read_list_int() : default;
                isPlayDieWhenRemove = _in.HasRemaining() ? _in.Read_boolean() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_UpdateEntities;}
            
            public override string ToString()
            {
                return "LevelLogic.UpdateEntities"+ ", modifiedList="+ modifiedList.ToString<LevelEntityPOD>()+ ", removedList="+ removedList.ToString<int>()+ ", isPlayDieWhenRemove="+ isPlayDieWhenRemove;
            }
        }
        public struct InteractResultData : IReceiveMessage {
        	private int? _code;
        	public int code {get{return _code == null ? -1 : (int)_code;}private set{_code = value;}}
	        public bool anyExecDone;
            public bool IsFail => _code != null && _code != 0;
            public bool IsSuccess =>_code != null && _code == 0;
            public bool IsCanceled => _code == null;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                code = _in.HasRemaining() ? _in.Read_int() : default;
                anyExecDone = _in.HasRemaining() ? _in.Read_boolean() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_InteractResult;}
            
            public override string ToString()
            {
                return "LevelLogic.InteractResult"+ ", code="+ code+ ", anyExecDone="+ anyExecDone;
            }
        }
        public struct LeaveResultData : IReceiveMessage {
        	private int? _code;
        	public int code {get{return _code == null ? -1 : (int)_code;}private set{_code = value;}}
            public bool IsFail => _code != null && _code != 0;
            public bool IsSuccess =>_code != null && _code == 0;
            public bool IsCanceled => _code == null;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                code = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_LeaveResult;}
            
            public override string ToString()
            {
                return "LevelLogic.LeaveResult"+ ", code="+ code;
            }
        }
        public struct JumpResultData : IReceiveMessage {
        	private int? _code;
        	public int code {get{return _code == null ? -1 : (int)_code;}private set{_code = value;}}
            public bool IsFail => _code != null && _code != 0;
            public bool IsSuccess =>_code != null && _code == 0;
            public bool IsCanceled => _code == null;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                code = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_JumpResult;}
            
            public override string ToString()
            {
                return "LevelLogic.JumpResult"+ ", code="+ code;
            }
        }
        public struct NotifyBattleSettlementData : IReceiveMessage {
	        public BattleSettlementPOD settlementPOD;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                settlementPOD = _in.HasRemaining() ? _in.Read_pod<BattleSettlementPOD>(BattleSettlementPOD.DynamicFactory) : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyBattleSettlement;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyBattleSettlement"+ ", settlementPOD="+ settlementPOD;
            }
        }
        public struct NotifyShowSpeechBubbleData : IReceiveMessage {
	        public int entityId;
	        public int bubbleGroupId;
	        public List<int> validBubbleIds;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                entityId = _in.HasRemaining() ? _in.Read_int() : default;
                bubbleGroupId = _in.HasRemaining() ? _in.Read_int() : default;
                validBubbleIds = _in.HasRemaining() ? _in.Read_list_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyShowSpeechBubble;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyShowSpeechBubble"+ ", entityId="+ entityId+ ", bubbleGroupId="+ bubbleGroupId+ ", validBubbleIds="+ validBubbleIds.ToString<int>();
            }
        }
        public struct UpdateEntityActivationData : IReceiveMessage {
	        public List<int> entityIdList;
	        public bool isActive;
	        public int animActionId;
	        public bool isSetRotation;
	        public int rotationY;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                entityIdList = _in.HasRemaining() ? _in.Read_list_int() : default;
                isActive = _in.HasRemaining() ? _in.Read_boolean() : default;
                animActionId = _in.HasRemaining() ? _in.Read_int() : default;
                isSetRotation = _in.HasRemaining() ? _in.Read_boolean() : default;
                rotationY = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_UpdateEntityActivation;}
            
            public override string ToString()
            {
                return "LevelLogic.UpdateEntityActivation"+ ", entityIdList="+ entityIdList.ToString<int>()+ ", isActive="+ isActive+ ", animActionId="+ animActionId+ ", isSetRotation="+ isSetRotation+ ", rotationY="+ rotationY;
            }
        }
        public struct NotifyActivateElevatorData : IReceiveMessage {
	        public int elevatorEntityId;
	        public int targetFloor;
	        public bool isRidingMode;
	        public bool isMoveState;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                elevatorEntityId = _in.HasRemaining() ? _in.Read_int() : default;
                targetFloor = _in.HasRemaining() ? _in.Read_int() : default;
                isRidingMode = _in.HasRemaining() ? _in.Read_boolean() : default;
                isMoveState = _in.HasRemaining() ? _in.Read_boolean() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyActivateElevator;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyActivateElevator"+ ", elevatorEntityId="+ elevatorEntityId+ ", targetFloor="+ targetFloor+ ", isRidingMode="+ isRidingMode+ ", isMoveState="+ isMoveState;
            }
        }
        public struct NotifyStartCameraMotionData : IReceiveMessage {
	        public int levelScreenSwitchCid;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                levelScreenSwitchCid = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyStartCameraMotion;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyStartCameraMotion"+ ", levelScreenSwitchCid="+ levelScreenSwitchCid;
            }
        }
        public struct NotifyEntityObstacleChangeData : IReceiveMessage {
	        public List<int> entityIds;
	        public bool isObstacleActive;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                entityIds = _in.HasRemaining() ? _in.Read_list_int() : default;
                isObstacleActive = _in.HasRemaining() ? _in.Read_boolean() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyEntityObstacleChange;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyEntityObstacleChange"+ ", entityIds="+ entityIds.ToString<int>()+ ", isObstacleActive="+ isObstacleActive;
            }
        }
        public struct NotifyPlayEntityAnimActionData : IReceiveMessage {
	        public List<int> entityIds;
	        public int actionId;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                entityIds = _in.HasRemaining() ? _in.Read_list_int() : default;
                actionId = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyPlayEntityAnimAction;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyPlayEntityAnimAction"+ ", entityIds="+ entityIds.ToString<int>()+ ", actionId="+ actionId;
            }
        }
        public struct NotifyLevelTimeShowChangeData : IReceiveMessage {
	        public int timeHour;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                timeHour = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyLevelTimeShowChange;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyLevelTimeShowChange"+ ", timeHour="+ timeHour;
            }
        }
        public struct NotifyChangeSceneEffectData : IReceiveMessage {
	        public int entityId;
	        public int sceneEffectId;
	        public bool isAdd;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                entityId = _in.HasRemaining() ? _in.Read_int() : default;
                sceneEffectId = _in.HasRemaining() ? _in.Read_int() : default;
                isAdd = _in.HasRemaining() ? _in.Read_boolean() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyChangeSceneEffect;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyChangeSceneEffect"+ ", entityId="+ entityId+ ", sceneEffectId="+ sceneEffectId+ ", isAdd="+ isAdd;
            }
        }
        public struct UpdateEntityRotationYData : IReceiveMessage {
	        public int entityId;
	        public LevelEntityType entityType;
	        public int rotationY;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                entityId = _in.HasRemaining() ? _in.Read_int() : default;
                entityType = _in.HasRemaining() ? (LevelEntityType)_in.Read_byte() : default;
                rotationY = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_UpdateEntityRotationY;}
            
            public override string ToString()
            {
                return "LevelLogic.UpdateEntityRotationY"+ ", entityId="+ entityId+ ", entityType="+ entityType+ ", rotationY="+ rotationY;
            }
        }
        public struct NotifyActiveCheckPointData : IReceiveMessage {
	        public int entityId;
	        public bool isActive;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                entityId = _in.HasRemaining() ? _in.Read_int() : default;
                isActive = _in.HasRemaining() ? _in.Read_boolean() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyActiveCheckPoint;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyActiveCheckPoint"+ ", entityId="+ entityId+ ", isActive="+ isActive;
            }
        }
        public struct NotifyBuffChangeData : IReceiveMessage {
	        public List<LevelBuffChangePOD> changes;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                changes = _in.HasRemaining() ? _in.Read_list_pod<LevelBuffChangePOD>(LevelBuffChangePOD.DynamicFactory) : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyBuffChange;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyBuffChange"+ ", changes="+ changes.ToString<LevelBuffChangePOD>();
            }
        }
        public struct NotifyCustomBgmChangeData : IReceiveMessage {
	        public int bgmAudioCid;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                bgmAudioCid = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyCustomBgmChange;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyCustomBgmChange"+ ", bgmAudioCid="+ bgmAudioCid;
            }
        }
        public struct NotifyStartStoryDialogData : IReceiveMessage {
	        public int cid;
	        public int jumpCid;
	        public int entityId;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                cid = _in.HasRemaining() ? _in.Read_int() : default;
                jumpCid = _in.HasRemaining() ? _in.Read_int() : default;
                entityId = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyStartStoryDialog;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyStartStoryDialog"+ ", cid="+ cid+ ", jumpCid="+ jumpCid+ ", entityId="+ entityId;
            }
        }
        public struct RepoStoryDialogSelectionResultData : IReceiveMessage {
        	private int? _code;
        	public int code {get{return _code == null ? -1 : (int)_code;}private set{_code = value;}}
            public bool IsFail => _code != null && _code != 0;
            public bool IsSuccess =>_code != null && _code == 0;
            public bool IsCanceled => _code == null;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                code = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_RepoStoryDialogSelectionResult;}
            
            public override string ToString()
            {
                return "LevelLogic.RepoStoryDialogSelectionResult"+ ", code="+ code;
            }
        }
        public struct NotifyChangeLevelParamData : IReceiveMessage {
	        public int key;
	        public int value;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                key = _in.HasRemaining() ? _in.Read_int() : default;
                value = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyChangeLevelParam;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyChangeLevelParam"+ ", key="+ key+ ", value="+ value;
            }
        }
        public struct NotifyHeroFollowerChangeData : IReceiveMessage {
	        public int id;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                id = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyHeroFollowerChange;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyHeroFollowerChange"+ ", id="+ id;
            }
        }
        public struct NotifyChangePlayerCameraData : IReceiveMessage {
	        public int cameraCid;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                cameraCid = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyChangePlayerCamera;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyChangePlayerCamera"+ ", cameraCid="+ cameraCid;
            }
        }
        public struct NotifyChangeWeatherData : IReceiveMessage {
	        public int id;
	        public int weatherType;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                id = _in.HasRemaining() ? _in.Read_int() : default;
                weatherType = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyChangeWeather;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyChangeWeather"+ ", id="+ id+ ", weatherType="+ weatherType;
            }
        }
        public struct GetMapEntitiesResultData : IReceiveMessage {
        	private int? _code;
        	public int code {get{return _code == null ? -1 : (int)_code;}private set{_code = value;}}
	        public List<LevelEntityMapPOD> entities;
            public bool IsFail => _code != null && _code != 0;
            public bool IsSuccess =>_code != null && _code == 0;
            public bool IsCanceled => _code == null;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                code = _in.HasRemaining() ? _in.Read_int() : default;
                entities = _in.HasRemaining() ? _in.Read_list_pod<LevelEntityMapPOD>(LevelEntityMapPOD.DynamicFactory) : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_GetMapEntitiesResult;}
            
            public override string ToString()
            {
                return "LevelLogic.GetMapEntitiesResult"+ ", code="+ code+ ", entities="+ entities.ToString<LevelEntityMapPOD>();
            }
        }
        public struct UpdateEntityAlertData : IReceiveMessage {
	        public int entityId;
	        public int targetEntityId;
	        public int alertValue;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                entityId = _in.HasRemaining() ? _in.Read_int() : default;
                targetEntityId = _in.HasRemaining() ? _in.Read_int() : default;
                alertValue = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_UpdateEntityAlert;}
            
            public override string ToString()
            {
                return "LevelLogic.UpdateEntityAlert"+ ", entityId="+ entityId+ ", targetEntityId="+ targetEntityId+ ", alertValue="+ alertValue;
            }
        }
        public struct UpdateHeroCarrierData : IReceiveMessage {
	        public int heroEntityId;
	        public int entityId;
	        public bool isRemoved;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                heroEntityId = _in.HasRemaining() ? _in.Read_int() : default;
                entityId = _in.HasRemaining() ? _in.Read_int() : default;
                isRemoved = _in.HasRemaining() ? _in.Read_boolean() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_UpdateHeroCarrier;}
            
            public override string ToString()
            {
                return "LevelLogic.UpdateHeroCarrier"+ ", heroEntityId="+ heroEntityId+ ", entityId="+ entityId+ ", isRemoved="+ isRemoved;
            }
        }
        public struct NotifyLeaderHeroChangedData : IReceiveMessage {
	        public int heroEntityId;
	        public LevelHeroPOD leaderHeroPOD;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                heroEntityId = _in.HasRemaining() ? _in.Read_int() : default;
                leaderHeroPOD = _in.HasRemaining() ? _in.Read_pod<LevelHeroPOD>(LevelHeroPOD.DynamicFactory) : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyLeaderHeroChanged;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyLeaderHeroChanged"+ ", heroEntityId="+ heroEntityId+ ", leaderHeroPOD="+ leaderHeroPOD;
            }
        }
        public struct NotifyStartItemSubmitData : IReceiveMessage {
	        public int itemSubmitCid;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                itemSubmitCid = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyStartItemSubmit;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyStartItemSubmit"+ ", itemSubmitCid="+ itemSubmitCid;
            }
        }
        public struct ConfirmItemSubmitResultData : IReceiveMessage {
        	private int? _code;
        	public int code {get{return _code == null ? -1 : (int)_code;}private set{_code = value;}}
	        public bool isSuccess;
            public bool IsFail => _code != null && _code != 0;
            public bool IsSuccess =>_code != null && _code == 0;
            public bool IsCanceled => _code == null;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                code = _in.HasRemaining() ? _in.Read_int() : default;
                isSuccess = _in.HasRemaining() ? _in.Read_boolean() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_ConfirmItemSubmitResult;}
            
            public override string ToString()
            {
                return "LevelLogic.ConfirmItemSubmitResult"+ ", code="+ code+ ", isSuccess="+ isSuccess;
            }
        }
        public struct AcceptQuestResultData : IReceiveMessage {
        	private int? _code;
        	public int code {get{return _code == null ? -1 : (int)_code;}private set{_code = value;}}
            public bool IsFail => _code != null && _code != 0;
            public bool IsSuccess =>_code != null && _code == 0;
            public bool IsCanceled => _code == null;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                code = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_AcceptQuestResult;}
            
            public override string ToString()
            {
                return "LevelLogic.AcceptQuestResult"+ ", code="+ code;
            }
        }
        public struct NotifyDropData : IReceiveMessage {
	        public int srcEntityId;
	        public List<ItemShowPOD> items;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                srcEntityId = _in.HasRemaining() ? _in.Read_int() : default;
                items = _in.HasRemaining() ? _in.Read_list_pod<ItemShowPOD>(ItemShowPOD.DynamicFactory) : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyDrop;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyDrop"+ ", srcEntityId="+ srcEntityId+ ", items="+ items.ToString<ItemShowPOD>();
            }
        }
        public struct NotifyClearHeroBuffData : IReceiveMessage {
	        public long pid;
	        public long heroId;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                pid = _in.HasRemaining() ? _in.Read_long() : default;
                heroId = _in.HasRemaining() ? _in.Read_long() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyClearHeroBuff;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyClearHeroBuff"+ ", pid="+ pid+ ", heroId="+ heroId;
            }
        }
        public struct NotifyTeamWipeData : IReceiveMessage {
	        public long pid;
	        public long leaderHeroId;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                pid = _in.HasRemaining() ? _in.Read_long() : default;
                leaderHeroId = _in.HasRemaining() ? _in.Read_long() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyTeamWipe;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyTeamWipe"+ ", pid="+ pid+ ", leaderHeroId="+ leaderHeroId;
            }
        }
        public struct NotifyHeroesAttrData : IReceiveMessage {
	        public long pid;
	        public List<LevelHeroAttrSyncPOD> heroAttrs;
	        public AttrChangeReason reason;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                pid = _in.HasRemaining() ? _in.Read_long() : default;
                heroAttrs = _in.HasRemaining() ? _in.Read_list_pod<LevelHeroAttrSyncPOD>(LevelHeroAttrSyncPOD.DynamicFactory) : default;
                reason = _in.HasRemaining() ? (AttrChangeReason)_in.Read_byte() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyHeroesAttr;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyHeroesAttr"+ ", pid="+ pid+ ", heroAttrs="+ heroAttrs.ToString<LevelHeroAttrSyncPOD>()+ ", reason="+ reason;
            }
        }
        public struct NotifyPlayOrStopEntityEffectData : IReceiveMessage {
	        public int singleEntityId;
	        public List<int> multiEntityIds;
	        public int effectResCid;
	        public int bindPointCid;
	        public bool isAdd;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                singleEntityId = _in.HasRemaining() ? _in.Read_int() : default;
                multiEntityIds = _in.HasRemaining() ? _in.Read_list_int() : default;
                effectResCid = _in.HasRemaining() ? _in.Read_int() : default;
                bindPointCid = _in.HasRemaining() ? _in.Read_int() : default;
                isAdd = _in.HasRemaining() ? _in.Read_boolean() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyPlayOrStopEntityEffect;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyPlayOrStopEntityEffect"+ ", singleEntityId="+ singleEntityId+ ", multiEntityIds="+ multiEntityIds.ToString<int>()+ ", effectResCid="+ effectResCid+ ", bindPointCid="+ bindPointCid+ ", isAdd="+ isAdd;
            }
        }
        public struct NotifyReviveData : IReceiveMessage {
	        public long pid;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                pid = _in.HasRemaining() ? _in.Read_long() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyRevive;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyRevive"+ ", pid="+ pid;
            }
        }
        public struct RequestReviveResultData : IReceiveMessage {
        	private int? _code;
        	public int code {get{return _code == null ? -1 : (int)_code;}private set{_code = value;}}
            public bool IsFail => _code != null && _code != 0;
            public bool IsSuccess =>_code != null && _code == 0;
            public bool IsCanceled => _code == null;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                code = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_RequestReviveResult;}
            
            public override string ToString()
            {
                return "LevelLogic.RequestReviveResult"+ ", code="+ code;
            }
        }
        public struct MarkTrackingEntityResultData : IReceiveMessage {
        	private int? _code;
        	public int code {get{return _code == null ? -1 : (int)_code;}private set{_code = value;}}
            public bool IsFail => _code != null && _code != 0;
            public bool IsSuccess =>_code != null && _code == 0;
            public bool IsCanceled => _code == null;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                code = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_MarkTrackingEntityResult;}
            
            public override string ToString()
            {
                return "LevelLogic.MarkTrackingEntityResult"+ ", code="+ code;
            }
        }
        public struct NotifyPushEntityData : IReceiveMessage {
	        public int entityId;
	        public int maxDistance;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                entityId = _in.HasRemaining() ? _in.Read_int() : default;
                maxDistance = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyPushEntity;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyPushEntity"+ ", entityId="+ entityId+ ", maxDistance="+ maxDistance;
            }
        }
        public struct SwitchPhasingResultData : IReceiveMessage {
        	private int? _code;
        	public int code {get{return _code == null ? -1 : (int)_code;}private set{_code = value;}}
            public bool IsFail => _code != null && _code != 0;
            public bool IsSuccess =>_code != null && _code == 0;
            public bool IsCanceled => _code == null;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                code = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_SwitchPhasingResult;}
            
            public override string ToString()
            {
                return "LevelLogic.SwitchPhasingResult"+ ", code="+ code;
            }
        }
        public struct NotifyStartMiniGameData : IReceiveMessage {
	        public LevelMiniGameType type;
	        public int miniGameCid;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                type = _in.HasRemaining() ? (LevelMiniGameType)_in.Read_byte() : default;
                miniGameCid = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyStartMiniGame;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyStartMiniGame"+ ", type="+ type+ ", miniGameCid="+ miniGameCid;
            }
        }
        public struct NotifyChangeEntityAudioData : IReceiveMessage {
	        public int entityId;
	        public int audioCid;
            public void FromPackage(ReceivePackage _package)
            {
                SInputStream _in = _package.InputStream;
                entityId = _in.HasRemaining() ? _in.Read_int() : default;
                audioCid = _in.HasRemaining() ? _in.Read_int() : default;
            }
            
            public int GetMessageId() {return NetMessageId.levelLogic_NotifyChangeEntityAudio;}
            
            public override string ToString()
            {
                return "LevelLogic.NotifyChangeEntityAudio"+ ", entityId="+ entityId+ ", audioCid="+ audioCid;
            }
        }
    }
#endregion
}